home *** CD-ROM | disk | FTP | other *** search
/ BBS in a Box 15 / BBS in a box XV-1.iso / Files / Util / C / Commodore 64 0.4.sit / Commodore 64 v0.4 / SOURCE / CpuC.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-05-01  |  17.1 KB  |  939 lines  |  [TEXT/KAHL]
  1. /*
  2.     Commodore 64 Emulator v0.4      Earle F. Philhower III 
  3.     Copyright (C) 1993-4            (st916w9r@dunx1.ocs.drexel.edu)
  4.  
  5.     This program is free software; you can redistribute it and/or modify
  6.     it under the terms of the GNU General Public License as published by
  7.     the Free Software Foundation; either version 2 of the License, or
  8.     (at your option) any later version.
  9.  
  10.     This program is distributed in the hope that it will be useful,
  11.     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12.     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13.     GNU General Public License for more details.
  14.  
  15.     You should have received a copy of the GNU General Public License
  16.     along with this program; if not, write to the Free Software
  17.     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. #include "Processor.h"
  21. #include "NewInstructions.h"
  22. #include "Stack.h"
  23. #include "Modes.h"
  24. #include "Error.h"
  25.  
  26. extern byte bcd2dec[], dec2bcd[], cycletime[], scanCode[];
  27.  
  28. /*
  29.     This is my Instructions.c file condensed into one single routine.
  30. */
  31. void IntegratedProcessor(byte *Ga, byte *Gx, byte *Gy, byte *Gflags, byte *Gsp, word *Gpc,
  32.                          byte **Gmemory, byte *GRAM)
  33. {
  34. /*
  35.     First we make local copies of the global variables.  These *should* be stored
  36.     within a register variable, but with TC, who knows!
  37. */
  38.     register byte a, x, y, flags, sp;
  39.     register word pc;
  40.     register byte **memory, **memoryp1, *RAM;
  41.     
  42.     register byte tbyte;
  43.     register word addr;
  44.     
  45.     int cycles, lines;
  46.     byte oldMemoryMap;
  47.  
  48.     a=*Ga; x=*Gx; y=*Gy; flags=*Gflags; sp=*Gsp; pc=*Gpc;
  49.     memory=Gmemory; memoryp1=memory+1; RAM=GRAM;
  50.     
  51.     oldMemoryMap=*RAMp1;
  52.  
  53.     lines=0;
  54.     while (++lines<350)
  55.     {
  56.         cycles=0;
  57.         while (cycles<35) 
  58.         {
  59.             tbyte=ImmediateByte(); pc++;
  60.             cycles+=cycletime[tbyte];
  61.             switch (tbyte)
  62.             {
  63.             case 0x00:
  64.                 PushWord(pc);
  65.                 flags |= BKC;
  66.                 Push(flags|BKC);
  67.                 pc=WordAt(IrqTo);
  68.                 break;
  69.             case 0x01:
  70.                 ORA(IndirectXAddr); pc++;
  71.                 break;
  72.             case 0x02:
  73.                 CRS();
  74.                 break;
  75.             case 0x03:
  76.                 LOR(IndirectXAddr); pc++;
  77.                 break;
  78.             case 0x04:
  79.                 SKP(1);
  80.                 break;
  81.             case 0x05:
  82.                 ORA(ZeroPageAddr); pc++;
  83.                 break;
  84.             case 0x06:
  85.                 ASL(ZeroPageAddr); pc++;
  86.                 break;
  87.             case 0x07:
  88.                 LOR(ZeroPageAddr); pc++;
  89.                 break;
  90.             case 0x08:
  91.                 Push(flags);
  92.                 break;
  93.             case 0x09:
  94.                 a |= ImmediateByte(); FlagsNZ(a); pc++;
  95.                 break;
  96.             case 0x0a:
  97.                 if (a&128) flags |= CAR;
  98.                 else flags &= ~CAR;
  99.                 a=a<<1;
  100.                 FlagsNZ(a);
  101.                 break;
  102.             case 0x0b:
  103.                 ANA(); pc++;
  104.                 break;
  105.             case 0x0c:
  106.                 SKP(2);
  107.                 break;
  108.             case 0x0d:
  109.                 ORA(AbsoluteAddr); pc+=2;
  110.                 break;
  111.             case 0x0e:
  112.                 ASL(AbsoluteAddr); pc+=2;
  113.                 break;
  114.             case 0x0f:
  115.                 LOR(AbsoluteAddr); pc+=2;
  116.                 break;
  117.             case 0x10:
  118.                 BCL(NEG);
  119.                 break;
  120.             case 0x11:
  121.                 ORA(IndirectYAddr); pc++;
  122.                 break;
  123.             case 0x12:
  124.                 CRS();
  125.                 break;
  126.             case 0x13:
  127.                 LOR(IndirectYAddr); pc++;
  128.                 break;
  129.             case 0x14:
  130.                 SKP(1);
  131.                 break;
  132.             case 0x15:
  133.                 ORA(ZeroPageXAddr); pc++;
  134.                 break;
  135.             case 0x16:
  136.                 ASL(ZeroPageXAddr); pc++;
  137.                 break;
  138.             case 0x17:
  139.                 LOR(ZeroPageXAddr); pc++;
  140.                 break;
  141.             case 0x18:
  142.                 CLR(CAR);
  143.                 break;
  144.             case 0x19:
  145.                 ORA(AbsoluteYAddr); pc+=2;
  146.                 break;
  147.             case 0x1a:
  148.                 pc++;
  149.                 break;
  150.             case 0x1b:
  151.                 LOR(AbsoluteYAddr); pc+=2;
  152.                 break;
  153.             case 0x1c:
  154.                 SKP(2);
  155.                 break;
  156.             case 0x1d:
  157.                 ORA(AbsoluteXAddr); pc+=2;
  158.                 break;
  159.             case 0x1e:
  160.                 ASL(AbsoluteXAddr); pc+=2;
  161.                 break;
  162.             case 0x1f:
  163.                 LOR(AbsoluteXAddr); pc+=2;
  164.                 break;
  165.             case 0x20:
  166.                 PushWord(pc+1); pc=WordAt(pc);
  167.                 break;
  168.             case 0x21:
  169.                 AND(IndirectXAddr); pc++;
  170.                 break;
  171.             case 0x22:
  172.                 CRS();
  173.                 break;
  174.             case 0x23:
  175.                 LAN(IndirectXAddr); pc+=2;
  176.                 break;
  177.             case 0x24:
  178.                 BIT(ZeroPageAddr); pc++;
  179.                 break;
  180.             case 0x25:
  181.                 AND(ZeroPageAddr); pc++;
  182.                 break;
  183.             case 0x26:
  184.                 ROL(ZeroPageAddr); pc++;
  185.                 break;
  186.             case 0x27:
  187.                 LAN(ZeroPageAddr); pc++;
  188.                 break;
  189.             case 0x28:
  190.                 flags = Pop();
  191.                 break;
  192.             case 0x29:
  193.                 a &= ImmediateByte(); FlagsNZ(a); pc++;
  194.                 break;
  195.             case 0x2a:
  196.                 if (flags&CAR) {
  197.                     if ((a&128)==0) flags &=~CAR;
  198.                     a=(a<<1)|1; }
  199.                 else {
  200.                     if(a&128)flags|=CAR;
  201.                     a=a<<1; }
  202.                 FlagsNZ(a);
  203.                 break;
  204.             case 0x2b:
  205.                 ANA(); pc++;
  206.                 break;
  207.             case 0x2c:
  208.                 BIT(AbsoluteAddr); pc+=2;
  209.                 break;
  210.             case 0x2d:
  211.                 AND(AbsoluteAddr); pc+=2;
  212.                 break;
  213.             case 0x2e:
  214.                 ROL(AbsoluteAddr); pc+=2;
  215.                 break;
  216.             case 0x2f:
  217.                 LAN(AbsoluteAddr); pc+=2;
  218.                 break;
  219.             case 0x30:
  220.                 BST(NEG);
  221.                 break;
  222.             case 0x31:
  223.                 AND(IndirectYAddr); pc++;
  224.                 break;
  225.             case 0x32:
  226.                 CRS();
  227.                 break;
  228.             case 0x33:
  229.                 LAN(IndirectYAddr); pc+=2;
  230.                 break;
  231.             case 0x34:
  232.                 SKP(1);
  233.                 break;
  234.             case 0x35:
  235.                 AND(ZeroPageXAddr); pc++;
  236.                 break;
  237.             case 0x36:
  238.                 ROL(ZeroPageXAddr); pc++;
  239.                 break;
  240.             case 0x37:
  241.                 LAN(ZeroPageXAddr); pc++;
  242.                 break;
  243.             case 0x38:
  244.                 SET(CAR);
  245.                 break;
  246.             case 0x39:
  247.                 AND(AbsoluteYAddr); pc+=2;
  248.                 break;
  249.             case 0x3a:
  250.                 pc++;
  251.                 break;
  252.             case 0x3b:
  253.                 LAN(AbsoluteYAddr); pc+=2;
  254.                 break;
  255.             case 0x3c:
  256.                 SKP(2);
  257.                 break;
  258.             case 0x3d:
  259.                 AND(AbsoluteXAddr); pc+=2;
  260.                 break;
  261.             case 0x3e:
  262.                 ROL(AbsoluteXAddr); pc+=2;
  263.                 break;
  264.             case 0x3f:
  265.                 LAN(AbsoluteXAddr); pc+=2;
  266.                 break;
  267.             case 0x40:
  268.                 flags=Pop(); PopWord(pc);
  269.                 break;
  270.             case 0x41:
  271.                 EOR(IndirectXAddr); pc++;
  272.                 break;
  273.             case 0x42:
  274.                 CRS();
  275.                 break;
  276.             case 0x43:
  277.                 REO(IndirectXAddr); pc+=2;
  278.                 break;
  279.             case 0x44:
  280.                 SKP(1);
  281.                 break;
  282.             case 0x45:
  283.                 EOR(ZeroPageAddr); pc++;
  284.                 break;
  285.             case 0x46:
  286.                 LSR(ZeroPageAddr); pc++;
  287.                 break;
  288.             case 0x47:
  289.                 REO(ZeroPageAddr); pc++;
  290.                 break;
  291.             case 0x48:
  292.                 Push(a);
  293.                 break;
  294.             case 0x49:
  295.                 a ^= ImmediateByte(); FlagsNZ(a); pc++;
  296.                 break;
  297.             case 0x4a:
  298.                 flags &=~(CAR+NEG+ZER);
  299.                 if (a&1) flags |=CAR;
  300.                 if (a=a>>1); else flags |=ZER;
  301.                 break;
  302.             case 0x4b:
  303.                 RBM(); pc++;
  304.                 break;
  305.             case 0x4c:
  306.                 pc=WordAt(pc);
  307.                 break;
  308.             case 0x4d:
  309.                 EOR(AbsoluteAddr); pc+=2;
  310.                 break;
  311.             case 0x4e:
  312.                 LSR(AbsoluteAddr); pc+=2;
  313.                 break;
  314.             case 0x4f:
  315.                 REO(AbsoluteAddr); pc+=2;
  316.                 break;
  317.             case 0x50:
  318.                 BCL(OVF);
  319.                 break;
  320.             case 0x51:
  321.                 EOR(IndirectYAddr); pc++;
  322.                 break;
  323.             case 0x52:
  324.                 CRS();
  325.                 break;
  326.             case 0x53:
  327.                 REO(IndirectYAddr); pc+=2;
  328.                 break;
  329.             case 0x54:
  330.                 SKP(1);
  331.                 break;
  332.             case 0x55:
  333.                 EOR(ZeroPageXAddr); pc++;
  334.                 break;
  335.             case 0x56:
  336.                 LSR(ZeroPageXAddr); pc++;
  337.                 break;
  338.             case 0x57:
  339.                 REO(ZeroPageXAddr); pc++;
  340.                 break;
  341.             case 0x58:
  342.                 CLR(INT);
  343.                 break;
  344.             case 0x59:
  345.                 EOR(AbsoluteYAddr); pc+=2;
  346.                 break;
  347.             case 0x5a:
  348.                 pc++;
  349.                 break;
  350.             case 0x5b:
  351.                 REO(AbsoluteYAddr); pc+=2;
  352.                 break;
  353.             case 0x5c:
  354.                 SKP(2);
  355.                 break;
  356.             case 0x5d:
  357.                 EOR(AbsoluteXAddr); pc+=2;
  358.                 break;
  359.             case 0x5e:
  360.                 LSR(AbsoluteXAddr); pc+=2;
  361.                 break;
  362.             case 0x5f:
  363.                 REO(AbsoluteXAddr); pc+=2;
  364.                 break;
  365.             case 0x60:
  366.                 PopWord(pc); pc++;
  367.                 break;
  368.             case 0x61:
  369.                 ADC(IndirectXAddr); pc++;
  370.                 break;
  371.             case 0x62:
  372.                 CRS();
  373.                 break;
  374.             case 0x63:
  375.                 RAD(IndirectXAddr); pc++;
  376.                 break;
  377.             case 0x64:
  378.                 SKP(1);
  379.                 break;
  380.             case 0x65:
  381.                 ADC(ZeroPageAddr); pc++;
  382.                 break;
  383.             case 0x66:
  384.                 ROR(ZeroPageAddr); pc++;
  385.                 break;
  386.             case 0x67:
  387.                 RAD(ZeroPageAddr); pc++;
  388.                 break;
  389.             case 0x68:
  390.                 a=Pop(); FlagsNZ(a);
  391.                 break;
  392.             case 0x69:
  393.                 addr=ImmediateByte();
  394.                 if (flags&DEC) {
  395.                     addr = bcd2dec[addr]+bcd2dec[a]+((flags&CAR)?1:0);
  396.                     flags &= ~(CAR+OVF+NEG+ZER);
  397.                     if (addr>99) {
  398.                         flags|=CAR+OVF;
  399.                         addr -=100; }
  400.                     if (addr==0) flags |= ZER;
  401.                     else flags |= addr&128;
  402.                     a=dec2bcd[addr];}
  403.                 else {
  404.                     addr += a+((flags&CAR)?1:0);
  405.                     flags &= ~(CAR+OVF+NEG+ZER);
  406.                     if (addr>255) {
  407.                         flags|=OVF+CAR;
  408.                         addr &=255; }
  409.                     if (addr==0) flags |= ZER;
  410.                     else flags |= addr&128;
  411.                     a=addr; }
  412.                 pc++;
  413.                 break;
  414.             case 0x6a:
  415.                 if (flags&CAR) {
  416.                     if ((a&1)==0) flags &=~CAR;
  417.                     a=(a>>1)|128; }
  418.                 else {
  419.                     if(a&1) flags|=CAR;
  420.                     a=a>>1; }
  421.                 FlagsNZ(a);
  422.                 break;
  423.             case 0x6b:
  424.                 RMAM(); pc++;
  425.                 break;
  426.             case 0x6c:
  427.                 addr=WordAt(pc); pc=WordAt(addr);
  428.                 break;
  429.             case 0x6d:
  430.                 ADC(AbsoluteAddr); pc+=2;
  431.                 break;
  432.             case 0x6e:
  433.                 ROR(AbsoluteAddr); pc+=2;
  434.                 break;
  435.             case 0x6f:
  436.                 RAD(AbsoluteAddr); pc+=2;
  437.                 break;
  438.             case 0x70:
  439.                 BST(OVF);
  440.                 break;
  441.             case 0x71:
  442.                 ADC(IndirectYAddr); pc++;
  443.                 break;
  444.             case 0x72:
  445.                 CRS();
  446.                 break;
  447.             case 0x73:
  448.                 RAD(IndirectYAddr); pc++;
  449.                 break;
  450.             case 0x74:
  451.                 SKP(1);
  452.                 break;
  453.             case 0x75:
  454.                 ADC(ZeroPageXAddr); pc++;
  455.                 break;
  456.             case 0x76:
  457.                 ROR(ZeroPageXAddr); pc++;
  458.                 break;
  459.             case 0x77:
  460.                 RAD(ZeroPageXAddr); pc++;
  461.                 break;
  462.             case 0x78:
  463.                 SET(INT);
  464.                 break;
  465.             case 0x79:
  466.                 ADC(AbsoluteYAddr); pc+=2;
  467.                 break;
  468.             case 0x7a:
  469.                 pc++;
  470.                 break;
  471.             case 0x7b:
  472.                 RAD(AbsoluteYAddr); pc+=2;
  473.                 break;
  474.             case 0x7c:
  475.                 SKP(2);
  476.                 break;
  477.             case 0x7d:
  478.                 ADC(AbsoluteXAddr); pc+=2;
  479.                 break;
  480.             case 0x7e:
  481.                 ROR(AbsoluteXAddr); pc+=2;
  482.                 break;
  483.             case 0x7f:
  484.                 RAD(AbsoluteXAddr); pc+=2;
  485.                 break;
  486.             case 0x80:
  487.                 SKP(1);
  488.                 break;
  489.             case 0x81:
  490.                 STA(IndirectXAddr); pc++;
  491.                 break;
  492.             case 0x82:
  493.                 SKP(1);
  494.                 break;
  495.             case 0x83:
  496.                 AAX(IndirectXAddr); pc++;
  497.                 break;
  498.             case 0x84:
  499.                 STY(ZeroPageAddr); pc++;
  500.                 break;
  501.             case 0x85:
  502.                 STA(ZeroPageAddr); pc++;
  503.                 break;
  504.             case 0x86:
  505.                 STX(ZeroPageAddr); pc++;
  506.                 break;
  507.             case 0x87:
  508.                 AAX(ZeroPageAddr); pc+=1;
  509.                 break;
  510.             case 0x88:
  511.                 y--; FlagsNZ(y);
  512.                 break;
  513.             case 0x89:
  514.                 SKP(1);
  515.                 break;
  516.             case 0x8a:
  517.                 a=x; FlagsNZ(a);
  518.                 break;
  519.             case 0x8b:
  520.                 XMA(); pc++;
  521.                 break;
  522.             case 0x8c:
  523.                 STY(AbsoluteAddr); pc+=2;
  524.                 break;
  525.             case 0x8d:
  526.                 STA(AbsoluteAddr); pc+=2;
  527.                 break;
  528.             case 0x8e:
  529.                 STX(AbsoluteAddr); pc+=2;
  530.                 break;
  531.             case 0x8f:
  532.                 AAX(AbsoluteAddr); pc+=2;
  533.                 break;
  534.             case 0x90:
  535.                 BCL(CAR);
  536.                 break;
  537.             case 0x91:
  538.                 STA(IndirectYAddr); pc++;
  539.                 break;
  540.             case 0x92:
  541.                 CRS();
  542.                 break;
  543.             case 0x93:
  544.                 AAX(IndirectYAddr); pc++;
  545.                 break;
  546.             case 0x94:
  547.                 STY(ZeroPageXAddr); pc++;
  548.                 break;
  549.             case 0x95:
  550.                 STA(ZeroPageXAddr); pc++;
  551.                 break;
  552.             case 0x96:
  553.                 STX(ZeroPageYAddr); pc++;
  554.                 break;
  555.             case 0x97:
  556.                 AAX(ZeroPageYAddr); pc++;
  557.                 break;
  558.             case 0x98:
  559.                 a=y; FlagsNZ(a);
  560.                 break;
  561.             case 0x99:
  562.                 STA(AbsoluteYAddr); pc+=2;
  563.                 break;
  564.             case 0x9a:
  565.                 sp=x;
  566.                 break;
  567.             case 0x9b:
  568.                 AXS(AbsoluteYAddr); pc+=2;
  569.                 break;
  570.             case 0x9c:
  571.                 TEY(AbsoluteXAddr); pc+=2;
  572.                 break;
  573.             case 0x9d:
  574.                 STA(AbsoluteXAddr); pc+=2;
  575.                 break;
  576.             case 0x9e:
  577.                 TEX(AbsoluteYAddr); pc+=2;
  578.                 break;
  579.             case 0x9f:
  580.                 TEA(AbsoluteYAddr); pc+=2;
  581.                 break;
  582.             case 0xa0:
  583.                 y=ImmediateByte(); FlagsNZ(y); pc++;
  584.                 break;
  585.             case 0xa1:
  586.                 LDA(IndirectXAddr); pc++;
  587.                 break;
  588.             case 0xa2:
  589.                 x=ImmediateByte(); FlagsNZ(x); pc++;
  590.                 break;
  591.             case 0xa3:
  592.                 LAX(IndirectXAddr); pc++;
  593.                 break;
  594.             case 0xa4:
  595.                 LDY(ZeroPageAddr); pc++;
  596.                 break;
  597.             case 0xa5:
  598.                 LDA(ZeroPageAddr); pc++;
  599.                 break;
  600.             case 0xa6:
  601.                 LDX(ZeroPageAddr); pc++;
  602.                 break;
  603.             case 0xa7:
  604.                 LAX(ZeroPageAddr); pc++;
  605.                 break;
  606.             case 0xa8:
  607.                 y=a; FlagsNZ(y);
  608.                 break;
  609.             case 0xa9:
  610.                 a=ImmediateByte(); FlagsNZ(a); pc++;
  611.                 break;
  612.             case 0xaa:
  613.                 x=a; FlagsNZ(x);
  614.                 break;
  615.             case 0xab:
  616.                 AMA(); pc++;
  617.                 break;
  618.             case 0xac:
  619.                 LDY(AbsoluteAddr); pc+=2;
  620.                 break;
  621.             case 0xad:
  622.                 LDA(AbsoluteAddr); pc+=2;
  623.                 break;
  624.             case 0xae:
  625.                 LDX(AbsoluteAddr); pc+=2;
  626.                 break;
  627.             case 0xaf:
  628.                 LAX(AbsoluteAddr); pc+=2;
  629.                 break;
  630.             case 0xb0:
  631.                 BST(CAR);
  632.                 break;
  633.             case 0xb1:
  634.                 LDA(IndirectYAddr); pc++;
  635.                 break;
  636.             case 0xb2:
  637.                 CRS();
  638.                 break;
  639.             case 0xb3:
  640.                 LAX(IndirectYAddr); pc++;
  641.                 break;
  642.             case 0xb4:
  643.                 LDY(ZeroPageXAddr); pc++;
  644.                 break;
  645.             case 0xb5:
  646.                 LDA(ZeroPageXAddr); pc++;
  647.                 break;
  648.             case 0xb6:
  649.                 LDX(ZeroPageYAddr); pc++;
  650.                 break;
  651.             case 0xb7:
  652.                 LAX(ZeroPageYAddr); pc++;
  653.                 break;
  654.             case 0xb8:
  655.                 CLR(OVF);
  656.                 break;
  657.             case 0xb9:
  658.                 LDA(AbsoluteYAddr); pc+=2;
  659.                 break;
  660.             case 0xba:
  661.                 x=sp;
  662.                 break;
  663.             case 0xbb:
  664.                 LAS(AbsoluteYAddr); pc+=2;
  665.                 break;
  666.             case 0xbc:
  667.                 LDY(AbsoluteXAddr); pc+=2;
  668.                 break;
  669.             case 0xbd:
  670.                 LDA(AbsoluteXAddr); pc+=2;
  671.                 break;
  672.             case 0xbe:
  673.                 LDX(AbsoluteYAddr); pc+=2;
  674.                 break;
  675.             case 0xbf:
  676.                 LAX(AbsoluteYAddr); pc+=2;
  677.                 break;
  678.             case 0xc0:
  679.                 tbyte=ImmediateByte();
  680.                 flags &=~(CAR+ZER+NEG);
  681.                 if (y==tbyte) flags |=CAR+ZER;
  682.                 else if (y>tbyte) flags |=CAR;
  683.                 else flags |=NEG;
  684.                 pc++;
  685.                 break;
  686.             case 0xc1:
  687.                 CMP(IndirectXAddr); pc++;
  688.                 break;
  689.             case 0xc2:
  690.                 SKP(1);
  691.                 break;
  692.             case 0xc3:
  693.                 DCP(IndirectXAddr); pc++;
  694.                 break;
  695.             case 0xc4:
  696.                 CPY(ZeroPageAddr); pc++;
  697.                 break;
  698.             case 0xc5:
  699.                 CMP(ZeroPageAddr); pc++;
  700.                 break;
  701.             case 0xc6:
  702.                 DECR(ZeroPageAddr); pc++;
  703.                 break;
  704.             case 0xc7:
  705.                 DCP(ZeroPageAddr); pc++;
  706.                 break;
  707.             case 0xc8:
  708.                 y++; FlagsNZ(y);
  709.                 break;
  710.             case 0xc9:
  711.                 tbyte=ImmediateByte();
  712.                 flags &=~(CAR+ZER+NEG);
  713.                 if (a==tbyte) flags |=CAR+ZER;
  714.                 else if (a>tbyte) flags |=CAR;
  715.                     else flags |=NEG;
  716.                 pc++;
  717.                 break;
  718.             case 0xca:
  719.                 x--; FlagsNZ(x);
  720.                 break;
  721.             case 0xcb:
  722.                 AXM(); pc++;
  723.                 break;
  724.             case 0xcc:
  725.                 CPY(AbsoluteAddr); pc+=2;
  726.                 break;
  727.             case 0xcd:
  728.                 CMP(AbsoluteAddr); pc+=2;
  729.                 break;
  730.             case 0xce:
  731.                 DECR(AbsoluteAddr); pc+=2;
  732.                 break;
  733.             case 0xcf:
  734.                 DCP(AbsoluteAddr); pc++;
  735.                 break;
  736.             case 0xd0:
  737.                 BCL(ZER);
  738.                 break;
  739.             case 0xd1:
  740.                 CMP(IndirectYAddr); pc++;
  741.                 break;
  742.             case 0xd2:
  743.                 CRS();
  744.                 break;
  745.             case 0xd3:
  746.                 DCP(IndirectYAddr); pc++;
  747.                 break;
  748.             case 0xd4:
  749.                 SKP(1);
  750.                 break;
  751.             case 0xd5:
  752.                 CMP(ZeroPageXAddr); pc++;
  753.                 break;
  754.             case 0xd6:
  755.                 DECR(ZeroPageXAddr); pc++;
  756.                 break;
  757.             case 0xd7:
  758.                 DCP(ZeroPageXAddr); pc++;
  759.                 break;
  760.             case 0xd8:
  761.                 CLR(DEC);
  762.                 break;
  763.             case 0xd9:
  764.                 CMP(AbsoluteYAddr); pc+=2;
  765.                 break;
  766.             case 0xda:
  767.                 pc++;
  768.                 break;
  769.             case 0xdb:
  770.                 DCP(AbsoluteYAddr); pc++;
  771.                 break;
  772.             case 0xdc:
  773.                 SKP(2);
  774.                 break;
  775.             case 0xdd:
  776.                 CMP(AbsoluteXAddr); pc+=2;
  777.                 break;
  778.             case 0xde:
  779.                 DECR(AbsoluteXAddr); pc+=2;
  780.                 break;
  781.             case 0xdf:
  782.                 DCP(AbsoluteXAddr); pc++;
  783.                 break;
  784.             case 0xe0:
  785.                 tbyte=ImmediateByte();
  786.                 flags &=~(CAR+ZER+NEG);
  787.                 if (x==tbyte) flags |=CAR+ZER;
  788.                 else if (x>tbyte) flags |=CAR;
  789.                 else flags |=NEG;
  790.                 pc++;
  791.                 break;
  792.             case 0xe1:
  793.                 SBC(IndirectXAddr); pc++;
  794.                 break;
  795.             case 0xe2:
  796.                 SKP(1);
  797.                 break;
  798.             case 0xe3:
  799.                 ISB(IndirectXAddr); pc++;
  800.                 break;
  801.             case 0xe4:
  802.                 CPX(ZeroPageAddr); pc++;
  803.                 break;
  804.             case 0xe5:
  805.                 SBC(ZeroPageAddr); pc++;
  806.                 break;
  807.             case 0xe6:
  808.                 INCR(ZeroPageAddr); pc++;
  809.                 break;
  810.             case 0xe7:
  811.                 ISB(ZeroPageAddr); pc++;
  812.                 break;
  813.             case 0xe8:
  814.                 x++; FlagsNZ(x);
  815.                 break;
  816.             case 0xe9:
  817.                 addr=ImmediateByte();
  818.                 if (flags&DEC) {
  819.                     addr = bcd2dec[a]-bcd2dec[addr]-((flags&CAR)?0:1);
  820.                     flags &= ~(CAR+ZER+NEG+OVF);
  821.                     if (addr==0) flags |=ZER+CAR;
  822.                     else if (((int)addr)>0) flags |=CAR;
  823.                         else {
  824.                             flags|=NEG;
  825.                             addr +=100; }
  826.                     a=dec2bcd[addr]; }
  827.                 else {
  828.                     addr = a-addr-((flags&CAR)?0:1);
  829.                     flags &=~(CAR+ZER+OVF+NEG);
  830.                     if (addr==0) flags |= ZER+CAR;
  831.                     else if (((int)addr)>0) flags |= CAR;
  832.                         else flags|=OVF;
  833.                     addr &= 255;
  834.                     flags |= addr&128;
  835.                     a=addr; }
  836.                 pc++; 
  837.                 break;
  838.             case 0xea:
  839.                 break;
  840.             case 0xeb:
  841.                 addr=ImmediateByte();
  842.                 if (flags&DEC) {
  843.                     addr = bcd2dec[a]-bcd2dec[addr]-((flags&CAR)?0:1);
  844.                     flags &= ~(CAR+ZER+NEG+OVF);
  845.                     if (addr==0) flags |=ZER+CAR;
  846.                     else if (((int)addr)>0) flags |=CAR;
  847.                         else {
  848.                             flags|=NEG;
  849.                             addr +=100; }
  850.                     a=dec2bcd[addr]; }
  851.                 else {
  852.                     addr = a-addr-((flags&CAR)?0:1);
  853.                     flags &=~(CAR+ZER+OVF+NEG);
  854.                     if (addr==0) flags |= ZER+CAR;
  855.                     else if (((int)addr)>0) flags |= CAR;
  856.                         else flags|=OVF;
  857.                     addr &= 255;
  858.                     flags |= addr&128;
  859.                     a=addr; }
  860.                 pc++; 
  861.                 break;
  862.             case 0xec:
  863.                 CPX(AbsoluteAddr); pc+=2;
  864.                 break;
  865.             case 0xed:
  866.                 SBC(AbsoluteAddr); pc+=2;
  867.                 break;
  868.             case 0xee:
  869.                 INCR(AbsoluteAddr); pc+=2;
  870.                 break;
  871.             case 0xef:
  872.                 ISB(AbsoluteAddr); pc+=2;
  873.                 break;
  874.             case 0xf0:
  875.                 BST(ZER);
  876.                 break;
  877.             case 0xf1:
  878.                 SBC(IndirectYAddr); pc++;
  879.                 break;
  880.             case 0xf2:
  881.                 CRS();
  882.                 break;
  883.             case 0xf3:
  884.                 ISB(IndirectYAddr); pc++;
  885.                 break;
  886.             case 0xf4:
  887.                 SKP(1);
  888.                 break;
  889.             case 0xf5:
  890.                 SBC(ZeroPageXAddr); pc++;
  891.                 break;
  892.             case 0xf6:
  893.                 INCR(ZeroPageXAddr); pc++;
  894.                 break;
  895.             case 0xf7:
  896.                 ISB(ZeroPageXAddr); pc++;
  897.                 break;
  898.             case 0xf8:
  899.                 SET(DEC);
  900.                 break;
  901.             case 0xf9:
  902.                 SBC(AbsoluteYAddr); pc+=2;
  903.                 break;
  904.             case 0xfa:
  905.                 pc++;
  906.                 break;
  907.             case 0xfb:
  908.                 ISB(AbsoluteYAddr); pc+=2;
  909.                 break;
  910.             case 0xfc:
  911.                 SKP(2);
  912.                 break;
  913.             case 0xfd:
  914.                 SBC(AbsoluteXAddr); pc+=2;
  915.                 break;
  916.             case 0xfe:
  917.                 INCR(AbsoluteXAddr); pc+=2;
  918.                 break;
  919.             case 0xff:
  920.  
  921. /*
  922.     This is out TRAP command for patching the ROMs.  First make sure
  923.     the global registers are set properly
  924. */
  925.                 *Ga=a; *Gx=x; *Gy=y; *Gflags=flags; *Gsp=sp; *Gpc=pc;
  926.                 TrapExecute();
  927.                 a=*Ga; x=*Gx; y=*Gy; flags=*Gflags; sp=*Gsp; pc=*Gpc;
  928.                 break;
  929.             }
  930.             /* Set up the keyboard register according to precomputed values */
  931.             RAM[0xdc01]=scanCode[RAM[0xdc00]];
  932.         }
  933.         if (++RAM[0xd012]==0) RAM[0xd011] ^= 128;
  934.         RAM[0xd018] |=1;
  935.     }
  936.     *Ga=a; *Gx=x; *Gy=y; *Gflags=flags; *Gsp=sp; *Gpc=pc;
  937. }
  938.  
  939.